home *** CD-ROM | disk | FTP | other *** search
/ Programming Languages Suite / ProgramD2.iso / Borland / Borland C++ V5.02 / GDIMETA.PAK / GDIMETA.C < prev    next >
C/C++ Source or Header  |  1997-05-06  |  14KB  |  520 lines
  1. // THIS CODE AND INFORMATION IS PROVIDED "AS IS" WITHOUT WARRANTY OF
  2. // ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING BUT NOT LIMITED TO
  3. // THE IMPLIED WARRANTIES OF MERCHANTABILITY AND/OR FITNESS FOR A
  4. // PARTICULAR PURPOSE.
  5. //
  6. // Copyright (C) 1993-1995  Microsoft Corporation.  All Rights Reserved.
  7. //
  8. //  MODULE: gdimeta.c
  9. //
  10. //  PURPOSE: Handles the main window for the GDI Input sample.
  11. //
  12. //  FUNCTIONS:
  13. //    WndProc            - Processes messages for the main window.
  14. //    MsgCommand         - Handle the WM_COMMAND messages for the main window.
  15. //    MsgCreate          - Handles the WM_CREATE message.  Creates the toolbar,
  16. //                         statusbar, and client windows.
  17. //    MsgSize            - Handles the WM_SIZE message by passing the message
  18. //                         on to the toolbar and statusbar controls and then
  19. //                         resizing the client window between them.
  20. //    MsgDestroy         - Handles the WM_DESTROY message by calling
  21. //                         PostQuitMessage().
  22. //    MsgPaletteChanged  - Passes WM_PALETTECHANGED message to
  23. //                         ProcessPaletteChanged
  24. //    MsgQueryNewPalette - Passes WM_QUERYNEWPALETTE message to
  25. //                         ProcessQueryNewPalette
  26. //    MsgQueryEndSession - Handles the case where user attempts to quit with
  27. //                         unsaved changes.
  28. //    MsgClose           - Close the application.
  29. //    CmdRefresh         - Forces client window to repaint.
  30. //    CmdExit            - Handles the file exit command by calling destroy
  31. //                         window on the main window.
  32. //    GetFName           - Get the current file name.
  33. //
  34. //  COMMENTS:
  35. //    Message dispatch table -
  36. //      For every message to be handled by the main window procedure
  37. //      place the message number and handler function pointer in
  38. //      rgmsd (the message dispatch table).  Place the prototype
  39. //      for the function in globals.h and the definition of the
  40. //      function in the appropriate module.
  41. //    Command dispatch table -
  42. //      For every command to be handled by the main window procedure
  43. //      place the command number and handler function pointer in
  44. //      rgcmd (the command dispatch table).  Place the prototype
  45. //      for the function in globals.h and the definition of the
  46. //      function in the appropriate module.
  47. //    Globals.h Contains the definitions of the structures and dispatch.c
  48. //      contains the functions that use these structures.
  49. //
  50.  
  51. #include <windows.h>            // required for all Windows applications
  52. #include <windowsx.h>
  53. #include <commctrl.h>           // prototypes and defs for common controls
  54. #include "globals.h"            // prototypes specific to this application
  55. #include "resource.h"
  56. #include "toolbar.h"            // prototypes for the tool bar
  57. #include "statbar.h"            // prototypes for the status bar
  58. #include "palette.h"            // prototypes for palette routines
  59.  
  60. // Global variables
  61. HWND      hWndClient;
  62. HPALETTE  hPalette;             // App's logical palette
  63. BOOL      bPalDevice = FALSE;
  64.  
  65.  
  66. // Main window message table definition.
  67. MSD rgmsd[] =
  68. {
  69.     {WM_MENUSELECT,      MsgMenuSelect},
  70.     {WM_COMMAND,         MsgCommand},
  71.     {WM_NOTIFY,          MsgNotify},
  72.     {WM_TIMER,           MsgTimer},
  73.     {WM_SIZE,            MsgSize},
  74.     {WM_QUERYENDSESSION, MsgQueryEndSession},
  75.     {WM_CLOSE,           MsgClose},
  76.     {WM_CREATE,          MsgCreate},
  77.     {WM_DESTROY,         MsgDestroy},
  78.  
  79.     // palette messages
  80.     {WM_PALETTECHANGED,  MsgPaletteChanged},
  81.     {WM_QUERYNEWPALETTE, MsgQueryNewPalette},
  82. };
  83.  
  84. MSDI msdiMain =
  85. {
  86.     sizeof(rgmsd) / sizeof(MSD),
  87.     rgmsd,
  88.     edwpWindow
  89. };
  90.  
  91.  
  92. // Main window command table definition.
  93. CMD rgcmd[] =
  94. {
  95.     {IDM_FILENEW,     CmdFileNew},
  96.     {IDM_FILEOPEN,    CmdFileOpen},
  97.     {IDM_FILESAVE,    CmdFileSave},
  98.     {IDM_FILESAVEAS,  CmdFileSaveAs},
  99.     {IDM_EXIT,        CmdExit},
  100.  
  101.     {IDM_INFO,        CmdInfo},
  102.  
  103.     {IDM_PIXEL,       CmdDrawMode},
  104.     {IDM_LINE,        CmdDrawMode},
  105.     {IDM_RECT,        CmdDrawMode},
  106.     {IDM_ELLIPSE,     CmdDrawMode},
  107.     {IDM_BEZIER,      CmdDrawMode},
  108.     {IDM_FILL,        CmdFill},
  109.     {IDM_NOFILL,      CmdFill},
  110.     {IDM_CREATEPEN,   CmdCreatePen},
  111.     {IDM_CREATEBRUSH, CmdCreateBrush},
  112.     {IDM_REFRESH,     CmdRefresh},
  113.  
  114.     {IDM_ABOUT,       CmdAbout}
  115. };
  116.  
  117. CMDI cmdiMain =
  118. {
  119.     sizeof(rgcmd) / sizeof(CMD),
  120.     rgcmd,
  121.     edwpWindow
  122. };
  123.  
  124.  
  125. //
  126. //  FUNCTION: WndProc(HWND, UINT, WPARAM, LPARAM)
  127. //
  128. //  PURPOSE:  Processes messages for the main window.
  129. //
  130. //  PARAMETERS:
  131. //    hwnd     - window handle
  132. //    uMessage - message number
  133. //    wparam   - additional information (dependant on message number)
  134. //    lparam   - additional information (dependant on message number)
  135. //
  136. //  RETURN VALUE:
  137. //    The return value depends on the message number.  If the message
  138. //    is implemented in the message dispatch table, the return value is
  139. //    the value returned by the message handling function.  Otherwise,
  140. //    the return value is the value returned by the default window procedure.
  141. //
  142. //  COMMENTS:
  143. //    Call the DispMessage() function with the main window's message dispatch
  144. //    information (msdiMain) and the message specific information.
  145. //
  146.  
  147. LRESULT CALLBACK WndProc(HWND   hwnd,
  148.                          UINT   uMessage,
  149.                          WPARAM wparam,
  150.                          LPARAM lparam)
  151. {
  152.     return DispMessage(&msdiMain, hwnd, uMessage, wparam, lparam);
  153. }
  154.  
  155.  
  156. //
  157. //  FUNCTION: MsgCommand(HWND, UINT, WPARAM, LPARAM)
  158. //
  159. //  PURPOSE: Handle the WM_COMMAND messages for the main window.
  160. //
  161. //  PARAMETERS:
  162. //    hwnd     - window handle
  163. //    uMessage - WM_COMMAND (Unused)
  164. //    GET_WM_COMMAND_ID(wparam, lparam)   - Command identifier
  165. //    GET_WM_COMMAND_HWND(wparam, lparam) - Control handle
  166. //
  167. //  RETURN VALUE:
  168. //    The return value depends on the message number.  If the message
  169. //    is implemented in the message dispatch table, the return value is
  170. //    the value returned by the message handling function.  Otherwise,
  171. //    the return value is the value returned by the default window procedure.
  172. //
  173. //  COMMENTS:
  174. //    Call the DispCommand() function with the main window's command dispatch
  175. //    information (cmdiMain) and the command specific information.
  176. //
  177.  
  178. #pragma argsused
  179. LRESULT MsgCommand(HWND hwnd, UINT uMessage, WPARAM wparam, LPARAM lparam)
  180. {
  181.     return DispCommand(&cmdiMain, hwnd, wparam, lparam);
  182. }
  183.  
  184.  
  185. //
  186. //  FUNCTION: MsgCreate(HWND, UINT, WPARAM, LPARAM)
  187. //
  188. //  PURPOSE: Handle the WM_CREATE messages for the main window.
  189. //           and call InitCommonControls() API to initialize the
  190. //           common control library.
  191. //
  192. //  PARAMETERS:
  193. //    hwnd     - window handle
  194. //
  195. //  RETURN VALUE:
  196. //    Return TRUE if the StatusBar and ToolBar Windows could be created
  197. //    successfully.
  198. //
  199. //  COMMENTS:
  200. //    Call the CreateTSBars function with the main window's window handle
  201. //    information (msdiMain).
  202. //
  203.  
  204. #pragma argsused
  205. LRESULT MsgCreate(HWND hwnd, UINT uMessage, WPARAM wparam, LPARAM lparam)
  206. {
  207.     int nRet = -1;                              // Assume failure
  208.  
  209.     InitCommonControls();   // Initialize the common control library.
  210.  
  211.     // check palette capabilities
  212.  
  213.     bPalDevice = IsPaletteDevice();
  214.  
  215.     if (bPalDevice)
  216.     {
  217.           HDC hdc;
  218.  
  219.         hdc = GetDC(hwnd);
  220.  
  221.         // create a default palette for choosing pen and brush colors
  222.         hPalette = CreateHalftonePalette(hdc);
  223.  
  224.         ReleaseDC(hwnd, hdc);
  225.     }
  226.  
  227.     if(CreateTBar(hwnd) && CreateSBar(hwnd))    // 1st create tool/status bars
  228.     {
  229.           hWndClient = CreateClientWindow(hwnd);  // then create client window
  230.         if (hWndClient != NULL)
  231.             nRet = 0;                           // Indicate success
  232.     }
  233.  
  234.     // Initialize some menu options...
  235.  
  236.     CmdDrawMode(hwnd, IDM_LINE, 0, NULL);   // Set initial draw mode to Line
  237.  
  238.     CmdFill(hwnd, IDM_NOFILL, 0, NULL);     // Turn fill mode OFF
  239.     CmdFill(hwnd, IDM_FILL, 0, NULL);       // Toggle fill state (ON)
  240.  
  241.      return nRet;
  242. }
  243.  
  244.  
  245. //
  246. //  FUNCTION: MsgSize(HWND, UINT, WPARAM, LPARAM)
  247. //
  248. //  PURPOSE:  This function resizes the toolbar and statusbar controls
  249. //    and the Client window which covers the rest of the main window
  250. //    client area.
  251. //
  252. //
  253. //  PARAMETERS:
  254. //
  255. //    hwnd      - Window handle  (Used)
  256. //    uMessage  - Message number (Used)
  257. //    wparam    - Extra data     (Used)
  258. //    lparam    - Extra data     (Used)
  259. //
  260. //  RETURN VALUE:
  261. //
  262. //    Always returns 0 - Message handled
  263. //
  264. //  COMMENTS:
  265. //
  266. //    When the window procdure that has the status and tool bar controls
  267. //    receives the WM_SIZE message, it has to pass the message on to these
  268. //    controls so that these controls can adjust their size accordingly.
  269. //
  270. //
  271.  
  272. LRESULT MsgSize(HWND hwnd, UINT uMessage, WPARAM wparam, LPARAM lparam)
  273. {
  274.     SendMessage(hWndToolbar, uMessage, wparam, lparam);
  275.     SendMessage(hWndStatusbar, uMessage, wparam, lparam);
  276.  
  277.     // Re-position the panes in the status bar
  278.     InitializeStatusBar(hwnd);
  279.  
  280.     // Re-size client window relative to the tool/status bars
  281.  
  282.     if (wparam != SIZE_MINIMIZED)
  283.     {
  284.         RECT rc, rcClient;
  285.  
  286.         GetClientRect(hwnd, &rcClient);
  287.  
  288.         GetWindowRect(hWndToolbar, &rc);
  289.         ScreenToClient(hwnd, ((LPPOINT)&rc) + 1);
  290.         rcClient.top = rc.bottom;
  291.  
  292.         GetWindowRect(hWndStatusbar, &rc);
  293.         ScreenToClient(hwnd, (LPPOINT)&rc);
  294.         rcClient.bottom = rc.top;
  295.  
  296.         MoveWindow(hWndClient,
  297.                    rcClient.left,
  298.                    rcClient.top,
  299.                    rcClient.right-rcClient.left,
  300.                    rcClient.bottom-rcClient.top,
  301.                    TRUE);
  302.     }
  303.  
  304.     return 0;
  305. }
  306.  
  307.  
  308. //
  309. //  FUNCTION: MsgDestroy(HWND, UINT, WPARAM, LPARAM)
  310. //
  311. //  PURPOSE: Calls PostQuitMessage().
  312. //
  313. //  PARAMETERS:
  314. //
  315. //    hwnd      - Window handle  (Unused)
  316. //    uMessage  - Message number (Unused)
  317. //    wparam    - Extra data     (Unused)
  318. //    lparam    - Extra data     (Unused)
  319. //
  320. //  RETURN VALUE:
  321. //
  322. //    Always returns 0 - Message handled
  323. //
  324. //  COMMENTS:
  325. //
  326. //
  327.  
  328. #pragma argsused
  329. LRESULT MsgDestroy(HWND hwnd, UINT uMessage, WPARAM wparam, LPARAM lparam)
  330. {
  331.      PostQuitMessage(0);
  332.     return 0;
  333. }
  334.  
  335.  
  336. //
  337. //  FUNCTION: MsgPaletteChanged(HWND, UINT, WPARAM, LPARAM)
  338. //
  339. //  PURPOSE: Passes WM_PALETTECHANGED message to handler.
  340. //
  341. //  PARAMETERS:
  342. //    hwnd -     Handle of application window.
  343. //    uMessage - (unused)
  344. //    wparam -   Handle of window that caused palette to change
  345. //    lparam -   (unused)
  346. //
  347. //  RETURN VALUE:
  348. //    Returns the value returned by ProcessPaletteChanged.
  349. //
  350. //  COMMENTS:
  351. //
  352.  
  353. #pragma argsused
  354. LRESULT MsgPaletteChanged(HWND   hwnd,
  355.                                   UINT   uMessage,
  356.                                   WPARAM wparam,
  357.                                   LPARAM lparam)
  358. {
  359.     return ProcessPaletteChanged(hwnd, wparam);
  360. }
  361.  
  362.  
  363. //
  364. //  FUNCTION: MsgQueryNewPalette(HWND, UINT, WPARAM, LPARAM)
  365. //
  366. //  PURPOSE: Passes WM_QUERYNEWPALETTE message to handler.
  367. //
  368. //  PARAMETERS:
  369. //    hwnd     - Handle of application window.
  370. //    uMessage - (unused)
  371. //    wparam   - (unused)
  372. //    lparam   - (unused)
  373. //
  374. //  RETURN VALUE:
  375. //    Returns the value returned by ProcessQueryNewPalette.
  376. //
  377. //  COMMENTS:
  378. //
  379.  
  380. #pragma argsused
  381. LRESULT MsgQueryNewPalette(HWND   hwnd,
  382.                                     UINT   uMessage,
  383.                                     WPARAM wparam,
  384.                            LPARAM lparam)
  385. {
  386.     return ProcessQueryNewPalette(hwnd);
  387. }
  388.  
  389.  
  390. //
  391. //  FUNCTION: MsgQueryEndSession(HWND, UINT, WPARAM, LPARAM)
  392. //
  393. //  PURPOSE: Handles the case where user attempts to quit with unsaved changes.
  394. //
  395. //  PARAMETERS:
  396. //    hwnd - The window handing the message.
  397. //    uMessage - The message number. (unused).
  398. //    wparam - Message specific data (unused).
  399. //    lparam - Message specific data (unused).
  400. //
  401. //  RETURN VALUE:
  402. //    TRUE - Quiting is now safe.
  403. //    FALSE - Don't quit.
  404. //
  405. //  COMMENTS:
  406. //    Let the function QuerySaveFile handle the real work.
  407. //
  408.  
  409. #pragma argsused
  410. LRESULT MsgQueryEndSession(HWND hwnd,
  411.                                     UINT uMessage,
  412.                            WPARAM wparam,
  413.                            LPARAM lparam)
  414. {
  415.     return QuerySaveFile(hwnd);
  416. }
  417.  
  418.  
  419. //
  420. //  FUNCTION: MsgClose(HWND, UINT, WPARAM, LPARAM)
  421. //
  422. //  PURPOSE: Close the application.
  423. //
  424. //  PARAMETERS:
  425. //    hwnd     - The window handing the message.
  426. //    uMessage - The message number. (unused).
  427. //    wparam   - Message specific data (unused).
  428. //    lparam   - Message specific data (unused).
  429. //
  430. //  RETURN VALUE:
  431. //    Always returns 0 - message handled.
  432. //
  433. //  COMMENTS:
  434. //
  435. //
  436.  
  437. #pragma argsused
  438. LRESULT MsgClose(HWND hwnd, UINT uMessage, WPARAM wparam, LPARAM lparam)
  439. {
  440.     if (QuerySaveFile(hwnd))
  441.         DestroyWindow(hwnd);
  442.     return 0;
  443. }
  444.  
  445.  
  446. //
  447. //  FUNCTION: CmdRefresh(HWND, WORD, WORD, HWND)
  448. //
  449. //  PURPOSE: Forces repaint of entire drawing.
  450. //
  451. //  PARAMETERS:
  452. //    hwnd     - The main window.
  453. //    wCommand - IDM_REFRESH (unused)
  454. //    wNotify  - Notification number (unused)
  455. //    hwndCtrl - NULL (unused)
  456. //
  457. //  RETURN VALUE:
  458. //    Always returns 0 - command handled.
  459. //
  460. //  COMMENTS:
  461. //
  462. //
  463.  
  464. #pragma argsused
  465. LRESULT CmdRefresh(HWND hwnd, WORD wCommand, WORD wNotify, HWND hwndCtrl)
  466. {
  467.     // Force client to repaint.
  468.     InvalidateRect(hWndClient, NULL, TRUE);
  469.      return 0;
  470. }
  471.  
  472.  
  473. //
  474. //  FUNCTION: CmdExit(HWND, WORD, WORD, HWND)
  475. //
  476. //  PURPOSE: Exit the application.
  477. //
  478. //  PARAMETERS:
  479. //    hwnd     - The window.
  480. //    wCommand - IDM_EXIT (unused)
  481. //    wNotify  - Notification number (unused)
  482. //    hwndCtrl - NULL (unused)
  483. //
  484. //  RETURN VALUE:
  485. //    Always returns 0 - command handled.
  486. //
  487. //  COMMENTS:
  488. //
  489. //
  490.  
  491. #pragma argsused
  492. LRESULT CmdExit(HWND hwnd, WORD wCommand, WORD wNotify, HWND hwndCtrl)
  493. {
  494.      if (QuerySaveFile(hwnd))
  495.           DestroyWindow(hwnd);
  496.      return 0;
  497. }
  498.  
  499. //
  500. //  FUNCTION: GetFName(VOID)
  501. //
  502. //  PURPOSE: Get the current file name.
  503. //
  504. //  PARAMETERS:
  505. //    NONE
  506. //
  507. //  RETURN VALUE:
  508. //    The full path name of the current file.
  509. //
  510. //  COMMENTS:
  511. //
  512. //
  513.  
  514. char *GetFName(VOID)
  515. {
  516.          return szFName;
  517. }
  518.  
  519.  
  520.